package com.zy.field;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ObjectCopier {

    /**
     * 复制对象并根据@DefineField注解的name值替换属性名
     * @param source 源对象
     * @return 复制后的对象(Map形式)
     */
    public static Map<String, Object> copyWithCustomNames(Object source) {
        if (source == null) {
            return null;
        }

        Map<String, Object> result = new HashMap<>();
        Class<?> clazz = source.getClass();
        Field[] fields = clazz.getDeclaredFields();

        for (Field field : fields) {
            // 跳过静态字段
            if (java.lang.reflect.Modifier.isStatic(field.getModifiers())) {
                continue;
            }

            try {
                field.setAccessible(true);
                Object value = field.get(source);
                String keyName = field.getName();

                // 检查是否有@DefineField注解
                if (field.isAnnotationPresent(DefineField.class)) {
                    DefineField defineField = field.getAnnotation(DefineField.class);
                    keyName = defineField.name();
                }

                // 处理值
                Object processedValue = processValue(value);
                result.put(keyName, processedValue);

            } catch (IllegalAccessException e) {
                // 更好的异常处理方式，例如使用日志框架
                throw new RuntimeException("无法访问字段: " + field.getName(), e);
            }
        }
        return result;
    }

    private static Object processValue(Object value) {
        if (value == null) {
            return null;
        }

        if (value instanceof List) {
            return processList((List<?>) value);
        } else if (hasDefineFieldAnnotation(value.getClass())) {
            return copyWithCustomNames(value);
        } else {
            return value;
        }
    }

    /**
     * 处理列表对象
     * @param list 列表
     * @return 处理后的列表
     */
    private static Object processList(List<?> list) {
        List<Object> newList = new ArrayList<>();
        for (Object item : list) {
            // 直接检查对象是否有@DefineField注解
            if (item != null && isCustomObject(item)) {
                if (hasDefineFieldAnnotation(item.getClass())) {
                    newList.add(copyWithCustomNames(item));
                } else {
                    newList.add(item);
                }
            } else {
                newList.add(item);
            }
        }
        return newList;
    }

    /**
     * 检查对象是否为自定义对象（非系统类）
     * @param obj 对象
     * @return 是否为自定义对象
     */
    private static boolean isCustomObject(Object obj) {
        String className = obj.getClass().getName();
        return !className.startsWith("java.") &&
                !className.startsWith("javax.") &&
                !className.startsWith("sun.");
    }

    /**
     * 检查类是否有@DefineField注解的字段
     * @param clazz 类
     * @return 是否有@DefineField注解
     */
    private static boolean hasDefineFieldAnnotation(Class<?> clazz) {
        // 排除系统类
        if (clazz.getName().startsWith("java.") ||
                clazz.getName().startsWith("javax.") ||
                clazz.getName().startsWith("sun.")) {
            return false;
        }

        try {
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                if (field.isAnnotationPresent(DefineField.class)) {
                    return true;
                }
            }
        } catch (Exception e) {
            // 忽略无法访问的类
            return false;
        }
        return false;
    }
}
